home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / rhythmbox / plugins / rb / Loader.py < prev    next >
Encoding:
Python Source  |  2009-04-07  |  8.9 KB  |  331 lines
  1. # -*- Mode: python; coding: utf-8; tab-width: 8; indent-tabs-mode: t; -*- 
  2. #
  3. # Copyright (C) 2009 - Jonathan Matthew
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2, or (at your option)
  8. # any later version.
  9. #
  10. # The Rhythmbox authors hereby grant permission for non-GPL compatible
  11. # GStreamer plugins to be used and distributed together with GStreamer
  12. # and Rhythmbox. This permission is above and beyond the permissions granted
  13. # by the GPL license by which Rhythmbox is covered. If you modify this code
  14. # you may extend this exception to your version of the code, but you are not
  15. # obligated to do so. If you do not wish to do so, delete this exception
  16. # statement from your version.
  17. # 
  18. # This program is distributed in the hope that it will be useful,
  19. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21. # GNU General Public License for more details.
  22. #
  23. # You should have received a copy of the GNU General Public License
  24. # along with this program; if not, write to the Free Software
  25. # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
  26.  
  27. import gobject
  28. import gtk
  29.  
  30. def callback_with_gdk_lock(callback, data, args):
  31.     gtk.gdk.threads_enter()
  32.     v = callback(data, *args)
  33.     gtk.gdk.threads_leave()
  34.     return v
  35.  
  36.  
  37. class GioLoader(object):
  38.     def __init__ (self):
  39.         self._cancel = gio.Cancellable()
  40.  
  41.     def _contents_cb (self, file, result):
  42.         try:
  43.             (contents, length, etag) = file.load_contents_finish(result)
  44.             callback_with_gdk_lock(self.callback, contents, self.args)
  45.         except gio.Error, e:
  46.             # somehow check if we just got cancelled
  47.             callback_with_gdk_lock(self.callback, None, self.args)
  48.  
  49.     def get_url (self, url, callback, *args):
  50.         self.url = url
  51.         self.callback = callback
  52.         self.args = args
  53.         try:
  54.             file = gio.File(url)
  55.             file.load_contents_async(callback = self._contents_cb, cancellable=self._cancel)
  56.         except Exception, e:
  57.             print "error getting contents of %s: %s" % e
  58.             callback(None, *args)
  59.  
  60.     def cancel (self):
  61.         self._cancel.cancel()
  62.  
  63.  
  64. class GioChunkLoader(object):
  65.     def __init__ (self):
  66.         self._cancel = gio.Cancellable()
  67.  
  68.     def _callback(self, result):
  69.         return self.callback(result, self.total, *self.args)
  70.  
  71.     def _callback_gdk(self, result):
  72.         gtk.gdk.threads_enter()
  73.         v = self._callback(result)
  74.         gtk.gdk.threads_leave()
  75.         return v
  76.  
  77.     def _read_cb(self, stream, result):
  78.         try:
  79.             data = stream.read_finish(result)
  80.         except gio.Error, e:
  81.             print "error reading file %s: %s" % (self.uri, e.message)
  82.             stream.close()
  83.             self._callback_gdk(e)
  84.  
  85.         if (self._callback_gdk(data) is not False) and data:
  86.             def again():
  87.                 stream.read_async (self.chunksize, self._read_cb, cancellable=self._cancel)
  88.                 return False
  89.             gobject.idle_add(again)
  90.         else:
  91.             # finished or cancelled by callback
  92.             stream.close()
  93.  
  94.     def _open_cb(self, file, result):
  95.         try:
  96.             stream = file.read_finish(result)
  97.         except gio.Error, e:
  98.             print "error reading file %s: %s" % (self.uri, e.message)
  99.             self._callback_gdk(e)
  100.         
  101.         stream.read_async(self.chunksize, self._read_cb, cancellable=self._cancel)
  102.  
  103.     def _info_cb(self, file, result):
  104.         try:
  105.             info = file.query_info_finish(result)
  106.             self.total = info.get_attribute_uint64(gio.FILE_ATTRIBUTE_STANDARD_SIZE)
  107.  
  108.             file.read_async(self._open_cb, cancellable=self._cancel)
  109.         except gio.Error, e:
  110.             print "error checking size of source file %s: %s" % (self.uri, e.message)
  111.             self._callback_gdk(e)
  112.  
  113.  
  114.     def get_url_chunks (self, uri, chunksize, want_size, callback, *args):
  115.         try:
  116.             self.uri = uri
  117.             self.chunksize = chunksize
  118.             self.total = 0
  119.             self.callback = callback
  120.             self.args = args
  121.  
  122.             file = gio.File(uri)
  123.             if want_size:
  124.                 file.query_info_async(self._info_cb, gio.FILE_ATTRIBUTE_STANDARD_SIZE, cancellable=self._cancel)
  125.             else:
  126.                 file.read_async(self._open_cb, cancellable=self.cancel)
  127.         except gio.Error, e:
  128.             print "error reading file %s: %s" % (uri, e.message)
  129.             self._callback(e)
  130.  
  131.     def cancel (self):
  132.         self._cancel.cancel()
  133.  
  134.  
  135. class GioUpdateCheck(object):
  136.     def __init__ (self):
  137.         self._cancel = gio.Cancellable()
  138.  
  139.     def _file_info_cb (self, file, result):
  140.         try:
  141.             rfi = file.query_info_finish(result)
  142.  
  143.             remote_mod = rfi.get_attribute_uint64(gio.FILE_ATTRIBUTE_TIME_MODIFIED)
  144.             callback_with_gdk_lock(self.callback, remote_mod != self.local_mod, self.args)
  145.         except Exception, e:
  146.             print "error checking for update: %s" % e
  147.             callback_with_gdk_lock(self.callback, False, self.args)
  148.  
  149.     def check_for_update (self, local, remote, callback, *args):
  150.         self.local = local
  151.         self.remote = remote
  152.         self.callback = callback
  153.         self.args = args
  154.  
  155.         try:
  156.             lf = gio.File(local)
  157.             lfi = lf.query_info(gio.FILE_ATTRIBUTE_TIME_MODIFIED)
  158.             self.local_mod = lfi.get_attribute_uint64(gio.FILE_ATTRIBUTE_TIME_MODIFIED)
  159.  
  160.             rf = gio.File(remote)
  161.             rf.query_info_async(self._file_info_cb, gio.FILE_ATTRIBUTE_TIME_MODIFIED, cancellable=self._cancel)
  162.         except Exception, e:
  163.             print "error checking for update: %s" % e
  164.             self.callback(True, *self.args)
  165.  
  166.     def cancel (self):
  167.         self._cancel.cancel()
  168.  
  169.  
  170. class GnomeVFSLoader (object):
  171.     def __init__ (self):
  172.         self.chunk = 4096
  173.  
  174.     def _read_cb (self, handle, buffer, exc_type, bytes_req):
  175.         if exc_type:
  176.             if issubclass (exc_type, gnomevfs.EOFError):
  177.                 callback_with_gdk_lock (self.callback, self.data, self.args)
  178.                 handle.close (lambda *args: None)
  179.             else:
  180.                 callback_with_gdk_lock (self.callback, None, self.args)
  181.                 handle.close (lambda *args: None)
  182.             return
  183.              
  184.         self.data += buffer
  185.         handle.read (self.chunk, self._read_cb)
  186.  
  187.     def _open_cb (self, handle, exc_type):
  188.         if exc_type:
  189.             callback_with_gdk_lock (self.callback, None, self.args)
  190.             return
  191.  
  192.         self.handle = handle
  193.         self.data = ""
  194.         handle.read (self.chunk, self._read_cb)
  195.     
  196.     def get_url (self, url, callback, *args):
  197.         self.url = url
  198.         self.callback = callback
  199.         self.args = args
  200.         gnomevfs.async.open (url, self._open_cb)
  201.  
  202.     def cancel (self):
  203.         self.handle.cancel()
  204.  
  205.  
  206. class GnomeVFSChunkLoader (object):
  207.     def __init__ (self):
  208.         pass
  209.  
  210.     def _callback(self, result):
  211.         return self.callback(result, self.total, *self.args)
  212.  
  213.     def _callback_gdk(self, result):
  214.         gtk.gdk.threads_enter()
  215.         v = self._callback(result)
  216.         gtk.gdk.threads_leave()
  217.         return v
  218.  
  219.     def _read_cb (self, handle, buffer, exc_type, bytes_requested):
  220.         if exc_type:
  221.             if issubclass (exc_type, gnomevfs.EOFError):
  222.                 self._callback_gdk (None)
  223.             else:
  224.                 self._callback_gdk (exc_type())
  225.             handle.close (lambda *args: None)
  226.         else:
  227.             if self._callback_gdk (buffer) is False:
  228.                 handle.close(lambda *args: None)
  229.             else:
  230.                 handle.read (self.chunksize, self._read_cb)
  231.  
  232.  
  233.     def _open_cb (self, handle, exc_type):
  234.         if exc_type:
  235.             self._callback_gdk (exc_type())
  236.         else:
  237.             handle.read (self.chunksize, self._read_cb)
  238.  
  239.     def _info_cb (self, handle, results):
  240.         try:
  241.             (uri, exc, info) = results[0]
  242.             self.total = info.size
  243.         except ValueError:
  244.             pass
  245.  
  246.         self.handle = gnomevfs.async.open (self.vfs_uri, self._open_cb)
  247.  
  248.     def get_url_chunks (self, uri, chunksize, want_size, callback, *args):
  249.         self.uri = uri
  250.         self.chunksize = chunksize
  251.         self.total = 0
  252.         self.callback = callback
  253.         self.args = args
  254.         self.vfs_uri = gnomevfs.URI(uri)
  255.         if want_size:
  256.             self.handle = gnomevfs.async.get_file_info ((self.vfs_uri,), self._info_cb)
  257.         else:
  258.             self.handle = gnomevfs.async.open (self.vfs_uri, self._open_cb)
  259.  
  260.     def cancel (self):
  261.         if self.handle:
  262.             self.handle.cancel()
  263.  
  264.  
  265. class GnomeVFSUpdateCheck (object):
  266.     def __init__ (self):
  267.         pass
  268.  
  269.     def _info_cb (self, handle, results):
  270.         (local_uri, local_exc, local_info) = results[0]
  271.         (remote_uri, remote_exc, remote_info) = results[1]
  272.  
  273.         result = True
  274.  
  275.         if remote_exc:
  276.             print "error checking remote URI %s: %s" % (self.remote, remote_exc)
  277.             result = False
  278.         elif local_exc:
  279.             if issubclass (local_exc, gnomevfs.NotFoundError):
  280.                 print "local URI %s not found" % self.local
  281.             else:
  282.                 print "error checking local URI %s: %s" % (self.local, local_exc)
  283.         else:
  284.             try:
  285.                 result = (remote_info.mtime > local_info.mtime)
  286.             except ValueError, e:
  287.                 print "error comparing modification times: %s" % e
  288.         
  289.         callback_with_gdk_lock (self.callback, result, self.args)
  290.  
  291.  
  292.     def check_for_update (self, local, remote, callback, *args):
  293.         self.callback = callback
  294.         self.args = args
  295.         self.local = local
  296.         self.remote = remote
  297.  
  298.         uris = (gnomevfs.URI(local), gnomevfs.URI(remote))
  299.         self.handle = gnomevfs.async.get_file_info (uris, self._info_cb)
  300.  
  301.     def cancel (self):
  302.         self.handle.cancel ()
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309. # now figure out which set of implementations to use
  310.  
  311. use_gio = False
  312. try:
  313.     import gio
  314.     # before 2.16.0, file.load_contents_async didn't work correctly
  315.     if gio.pygio_version > (2,15,4):
  316.         use_gio = True
  317. except:
  318.     # probably don't have gio at all
  319.     pass
  320.  
  321. if use_gio:
  322.     Loader = GioLoader
  323.     ChunkLoader = GioChunkLoader
  324.     UpdateCheck = GioUpdateCheck
  325. else:
  326.     import gnomevfs
  327.     Loader = GnomeVFSLoader
  328.     ChunkLoader = GnomeVFSChunkLoader
  329.     UpdateCheck = GnomeVFSUpdateCheck
  330.  
  331.